#!/usr/bin/env python
# -*- coding: UTF8 	-*-

from GladeConnect import GladeConnect
import gtk
import sys
import time
import datetime
import dialogos
import debugwindow
import SimpleTree
import ifd
from strSQL import maceracion, fermentacion, control_aplicacion, basicas
from strSQL import recepcion_insumo, recepcion_uva, mezcla, embotellado
from strSQL.recepcion_insumo import strSelectFiltroRecepcionInsumo, strSelectFiltroRecepcionSaldo
from strSQL.maceracion import strSelectMaceracionRecepcionUva
from strSQL.mezcla import strSelectFiltroMezcla, strSelectDespachoMezcla
from strSQL.embotellado import *
from psycopg2 import connect
import completion
import comunes
from pyBusqueda import pyBusqueda

(CODIGO_APLICACION,
 CANTIDAD_APLICACION,
 MERMA_APLICACION,
 CODIGO_INSUMO_APLICACION,
 DESCRIPCION_INSUMO_APLICACION,
 CODIGO_RECEPCION,
 DOSIS,
 FECHA_APLICACION,
 HORA_APLICACION,
 RUT_APLICACION,
 NOMBRE_APLICACION) = range(11)

class vboxAplicacion(GladeConnect):
    
    def __init__(self, conexion=None, padre=None, root="vboxAplicacion"):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        
        self.padre = padre
        self.rut_aplicacion = None
        self.codigo_insumo_aplicacion = None
        self.codigo_tipo_aplicacion = None
        self.saldo = None
        self.diferencia_cantidad = None
        self.diferencia_merma = None
        self.codigos = []
        
        if padre is None:
            self.frm_padre = self.wnAplicacion
        else:
            self.frm_padre = self.padre.frm_padre
            
        self.pecResponsableAplicacion = completion.CompletionEmpleado(self.entResponsableAplicacion,
                                            self.sel_responsable,
                                            self.cnx)
        self.pecInsumoAplicacion = completion.CompletionInsumo(self.entInsumoAplicacion,
                                    self.sel_insumo,
                                    self.cnx)
        self.pecInsumoAplicacion.set_popup_completion(False)
        
        hora = str(time.localtime()[3]).zfill(2)
        minuto = str(time.localtime()[4]).zfill(2)
        self.entFechaAplicacion.set_date(datetime.date.today())
        self.entHoraAplicacion.set_text("%s:%s" % (hora, minuto))
        
        self.crea_columnas()
        self.frm_padre.show_all()
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_APLICACION, "Código", "str"])
        columnas.append ([CANTIDAD_APLICACION, "Cantidad", "str"])
        columnas.append ([MERMA_APLICACION, "Merma", "str"])
        columnas.append ([DESCRIPCION_INSUMO_APLICACION, "Insumo", "str"])
        columnas.append ([CODIGO_RECEPCION, "Recepción", "str"])
        columnas.append ([DOSIS, "Dosis", "str"])
        columnas.append ([FECHA_APLICACION, "Fecha","dte"])
        columnas.append ([HORA_APLICACION, "Hora", "str"])
        columnas.append ([NOMBRE_APLICACION, "Responsable", "str"])
        
        self.modelo_aplicacion = gtk.ListStore(*(11*[str]))
        SimpleTree.GenColsByModel(self.modelo_aplicacion, columnas, self.treeAplicacion)
        
    def sel_responsable(self, completion, model, iter):
        self.rut_aplicacion = model.get_value(iter, 1)
    
    def sel_insumo(self, completion, model, iter):
        self.codigo_insumo_aplicacion = model.get_value(iter, 1)
        self.multi_insumo()
        
    def multi_insumo(self):
        if self.codigos != []:
            sql = strSelectFiltroRecepcionSaldo % " r.codigo_insumo = %s" % self.codigo_insumo_aplicacion
            for i in self.codigos:
                if len(self.codigos) > 0:
                    if self.codigos[0] == i:
                        sql = sql.replace("group", "and not r.codigo_recepcion_insumo = %s " % i +"group")
                    else:
                        if self.codigos[1] == i:
                            sql = sql.replace("not ", "not (")
                            sql = sql.replace("group", "or r.codigo_recepcion_insumo = %s ) group" % i)
                        else:
                            sql = sql.replace(") group", " or r.codigo_recepcion_insumo = %s ) group" % i)
        else:
            sql = strSelectFiltroRecepcionSaldo % " r.codigo_insumo = %s" % self.codigo_insumo_aplicacion
        titulos = ["Código",
                    "Descripción Insumo",
                    "Saldo",
                    "Cantidad",
                    "Unidad",
                    "Fecha",
                    "Hora",
                    "Vence",
                    "Lote",
                    "Documento",
                    "Tipo",
                    "Proveedor"]
        
        self.cursor.execute(sql)
        r = self.cursor.dictfetchall()
        if len(r) > 0:
            busqueda = pyBusqueda(self.frm_padre, self.cnx, sql, 1, 0, titulos)
            if not busqueda.is_filter:
                self.entInsumoAplicacion.set_text("")
                self.codigo_insumo_aplicacion = None
                self.pecInsumoAplicacion.set_selected(False)
                return
            
            r = busqueda.run()
            model, it = busqueda.list.get_selection().get_selected()
            
            if not it is None:
                self.entCodigoRecepcionInsumo.set_text(model.get_value(it, 0))
                self.saldo = model.get_value(it, 2)
            
            busqueda.destroy()
            return True
        else:
            return False

    def guarda_modelo(self, codigo, tabla):
        campo_llave = "codigo_%s" % tabla
        llaves = {campo_llave: codigo}
        
        sql = ifd.deleteFromDict("traza.aplicacion_producto", llaves)
        self.cursor.execute(sql, llaves)
        
        if self.modelo_aplicacion is None:
            return
        
        for i in self.modelo_aplicacion:
            campos = {}
            campos['cantidad'] = i[CANTIDAD_APLICACION]
            campos['merma'] = i[MERMA_APLICACION]
            if i[CODIGO_APLICACION] != "":
                campos['codigo_aplicacion'] = i[CODIGO_APLICACION]
            campos[campo_llave] = codigo
            campos['codigo_recepcion_insumo'] = i[CODIGO_RECEPCION]
            campos['dosis'] = i[DOSIS]
            campos['fecha_aplicacion'] = i[FECHA_APLICACION][:10]
            campos['hora_aplicacion'] = i[HORA_APLICACION][:5]
            campos['rut_responsable'] = i[RUT_APLICACION]
           
            sql = ifd.insertFromDict("traza.aplicacion_producto", campos)
            self.cursor.execute(sql, campos)

    def carga_modelo(self, codigo, tabla):
        campo_llave = "codigo_%s" % tabla
        llaves = {campo_llave: codigo}
        
        self.modelo_aplicacion = ifd.ListStoreFromSQL(self.cnx,
                                    control_aplicacion.strSelectDetalleAplicacion % (tabla, codigo))
        if self.modelo_aplicacion is None:
            self.modelo_aplicacion = gtk.ListStore(*(11*[str]))
            
        self.treeAplicacion.set_model(self.modelo_aplicacion)
        
    def on_btnAnadirAplicacion_clicked(self, btn=None):
        busqueda = None
        
        if self.rut_aplicacion is None:
            dialogos.error("Debe indicar un responsable")
            return
        
        if self.codigo_insumo_aplicacion is None:
            dialogos.error("Debe indicar un insumo")
            return
        if self.saldo is None:
            if self.entCodigoRecepcionInsumo.get_text() != "":
                self.multi_insumo()
            else:
                self.entInsumoAplicacion.set_text("")
                dialogos.error("Debe indicar un insumo o un Codigo Recepcion Insumo")
                return
        
        cantidad = self.spnCantidadAplicacion.get_value()
        merma = self.spnMermaAplicacion.get_value()
        total = cantidad + merma
        self.diferencia_merma = 0
        self.diferencia_cantidad = 0
        
        
        if float(self.saldo) < total:
            if float(self.saldo) < cantidad:
                self.diferencia_cantidad = cantidad - float(self.saldo)
                self.diferencia_merma = merma
                cantidad = float(self.saldo)
                merma = 0
            elif (float(self.saldo) - cantidad) < merma:
                self.diferencia_cantidad = 0
                self.diferencia_merma = merma - (float(self.saldo) - cantidad)
                merma = float(self.saldo) - cantidad
        elif float(self.saldo) < cantidad:
            self.diferencia_cantidad = cantidad - float(self.saldo)
            self.diferencia_merma = merma - (float(self.saldo) - cantidad)
            merma = float(self.saldo) - cantidad
        elif float(self.saldo) < merma:
            self.diferencia_cantidad = 0
            self.diferencia_merma = merma - (float(self.saldo) - cantidad)
            merma = float(self.saldo) - cantidad
        #elif float(self.saldo) > total:
        #    self.diferencia_cantidad = 0
        #    self.diferencia_merma = 0
        #else:
        #    self.diferencia_cantidad = None
        #    self.diferencia_merma = None
        
        it = self.modelo_aplicacion.append()
        
        self.modelo_aplicacion.set_value(it, CODIGO_APLICACION, self.entCodigoAplicacion.get_text())
        self.modelo_aplicacion.set_value(it, CANTIDAD_APLICACION, cantidad)
        self.modelo_aplicacion.set_value(it, MERMA_APLICACION, merma)
        self.modelo_aplicacion.set_value(it, CODIGO_INSUMO_APLICACION, self.codigo_insumo_aplicacion)
        self.modelo_aplicacion.set_value(it, DESCRIPCION_INSUMO_APLICACION, self.entInsumoAplicacion.get_text())
        self.modelo_aplicacion.set_value(it, CODIGO_RECEPCION, self.entCodigoRecepcionInsumo.get_text())
        self.modelo_aplicacion.set_value(it, DOSIS, self.entDosis.get_text())
        self.modelo_aplicacion.set_value(it, FECHA_APLICACION, self.entFechaAplicacion.get_date())
        self.modelo_aplicacion.set_value(it, HORA_APLICACION, self.entHoraAplicacion.get_text())
        self.modelo_aplicacion.set_value(it, RUT_APLICACION, self.rut_aplicacion)
        self.modelo_aplicacion.set_value(it, NOMBRE_APLICACION, self.entResponsableAplicacion.get_text())
        
        if self.diferencia_cantidad != 0 or self.diferencia_merma != 0:
            self.codigos.append(self.entCodigoRecepcionInsumo.get_text())
            if self.multi_insumo():
                if self.diferencia_cantidad is not None:
                    self.spnCantidadAplicacion.set_value(float(self.diferencia_cantidad))
                else:
                    self.spnCantidadAplicacion.set_value(0)
                if self.diferencia_merma is not None:
                    self.spnMermaAplicacion.set_value(float(self.diferencia_merma))
                else:
                    self.spnMermaAplicacion.set_value(0)
                self.on_btnAnadirAplicacion_clicked()
            else:
                self.limpia_formulario()
        else:    
            self.limpia_formulario()
            
        if (self.diferencia_cantidad is None or self.diferencia_merma is None) \
            or ( self.diferencia_cantidad == 0 and self.diferencia_merma == 0):
            self.limpia_formulario()
        #aki llenar formulario con datos
    
    def limpia_formulario(self):
        #self.rut_aplicacion = None
        self.entResponsableAplicacion.grab_focus()
        self.codigo_insumo_aplicacion = None
        self.codigo_tipo_aplicacion = None
        self.entCodigoAplicacion.set_text("")
        self.spnCantidadAplicacion.set_value(0)
        self.spnMermaAplicacion.set_value(0)
        self.entInsumoAplicacion.set_text("")
        self.entCodigoRecepcionInsumo.set_text("")
        self.entDosis.set_text("")
        #self.entResponsableAplicacion.set_text("")
        self.saldo = None
        self.diferencia_cantidad = None
        self.diferencia_merma = None
        #self.codigos = []
        
    def on_treeAplicacion_row_activated(self, tree, path, col):
        self.limpia_formulario()
        model, it = self.treeAplicacion.get_selection().get_selected()
        if model is None or it is None:
            return
        
        self.entCodigoAplicacion.set_text(model.get_value(it, CODIGO_APLICACION))
        self.codigo_insumo_aplicacion = self.pecInsumoAplicacion.select(model.get_value(it, DESCRIPCION_INSUMO_APLICACION), 1)
        self.spnCantidadAplicacion.set_value(float(model.get_value(it, CANTIDAD_APLICACION)))
        self.spnMermaAplicacion.set_value(float(model.get_value(it, MERMA_APLICACION)))
        self.entCodigoRecepcionInsumo.set_text(model.get_value(it, CODIGO_RECEPCION))
        self.entDosis.set_text(model.get_value(it, DOSIS))
        fecha = comunes.GetDateFromModel(model.get_value(it, FECHA_APLICACION).split()[0])
        self.entFechaAplicacion.set_date(fecha)
        self.entHoraAplicacion.set_text(model.get_value(it, HORA_APLICACION))
        self.rut_aplicacion = self.pecResponsableAplicacion.select(model.get_value(it, NOMBRE_APLICACION), 1)
        
        try:
            self.codigos.remove(model.get_value(it, CODIGO_RECEPCION))
        except:
            pass
        
        model.remove(it)        
        
    def on_btnQuitarAplicacion_clicked(self, btn=None):
        model, it = self.treeAplicacion.get_selection().get_selected()
        
        if model is None or it is None:
            return
        model.remove(it)


(CODIGO_CONTROL,
 CODIGO_TIPO_CONTROL,
 DESCRIPCION_TIPO_CONTROL,
 RESULTADO_CONTROL,
 DESCRIPCION_RESULTADO,
 UNIDAD_MEDICION,
 FECHA_CONTROL,
 HORA_CONTROL,
 RUT_CONTROL,
 NOMBRE_CONTROL) = range(10)

class vboxControl(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="vboxControl"):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        
        self.padre = padre
        self.rut_control = None
        self.codigo_tipo_control = None
        
        if padre is None:
            self.frm_padre = self.wnControl
        else:
            self.frm_padre = self.padre.frm_padre
            
        self.pecResponsableControl = completion.CompletionEmpleado(self.entResponsableControl,
                                        self.sel_responsable, self.cnx)
        self.pecTipoControl = completion.CompletionTipoControl(self.entTipoControl,
                                        self.sel_tipo_control, self.cnx)
        
        hora = str(time.localtime()[3]).zfill(2)
        minuto = str(time.localtime()[4]).zfill(2)
        self.entFechaControl.set_date(datetime.date.today())
        self.entHoraControl.set_text("%s:%s" % (hora, minuto))
        self.modelo_control = None
        self.crea_columnas()
        self.hbResultadoN.set_sensitive(False)
        self.hbResultadoT.set_sensitive(False)
        self.frm_padre.show_all()
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_CONTROL, "Código", "str"])
        columnas.append ([DESCRIPCION_TIPO_CONTROL, "Control", "str"])
        columnas.append ([RESULTADO_CONTROL, "Valor Núm.", "str"])
        columnas.append ([DESCRIPCION_RESULTADO, "Valor Texto", "str"])
        columnas.append ([UNIDAD_MEDICION, "Unidad", "str"])
        columnas.append ([FECHA_CONTROL, "Fecha","dte"])
        columnas.append ([HORA_CONTROL, "Hora", "str"])
        columnas.append ([NOMBRE_CONTROL, "Responsable", "str"])
        
        self.modelo_control = gtk.ListStore(*(10*[str]))
        SimpleTree.GenColsByModel(self.modelo_control, columnas, self.treeControl)
        
    def sel_responsable(self, completion, model, iter):
        self.rut_control = model.get_value(iter, 1)
    
    def sel_tipo_control(self, completion, model, iter):
        self.codigo_tipo_control = model.get_value(iter, 2)
        self.descripcion_unidad = model.get_value(iter,1)
        tipo = model.get_value(iter, 4)
        if tipo == "N":
            self.hbResultadoN.set_sensitive(True)
            self.hbResultadoT.set_sensitive(False)
            self.entResultadoN.set_text(model.get_value(iter,1))
            self.entResultadoT.set_text("")
        else:
            self.hbResultadoN.set_sensitive(False)
            self.hbResultadoT.set_sensitive(True)
            self.entResultadoT.set_text(model.get_value(iter,1))
            self.entResultadoN.set_text("")
    
    def guarda_modelo(self, codigo, tabla):
        campo_llave = "codigo_%s" % tabla
        llaves = {campo_llave: codigo}
        
        # Elimina todos los registros anteriores
        sql = ifd.deleteFromDict("traza.control", llaves)
        self.cursor.execute(sql, llaves)
        
        if self.modelo_control is None:
            return
        
        for i in self.modelo_control:
            campos = {}
            if i[CODIGO_CONTROL] != "":
                campos['codigo_control'] = i[CODIGO_CONTROL]
            campos[campo_llave] = codigo
            campos['codigo_tipo_control'] = i[CODIGO_TIPO_CONTROL]
            campos['descripcion_resultado'] = i[DESCRIPCION_RESULTADO]
            campos['fecha_control'] = i[FECHA_CONTROL][:10]
            campos['hora_control'] = i[HORA_CONTROL][:5]
            campos['resultado_control'] = i[RESULTADO_CONTROL]
            campos['rut_responsable'] = i[RUT_CONTROL]
           
            sql = ifd.insertFromDict("traza.control", campos)
            self.cursor.execute(sql, campos)

    def carga_modelo(self, codigo, tabla):
        campo_llave = "codigo_%s" % tabla
        llaves = {campo_llave: codigo}
        
        self.modelo_control = ifd.ListStoreFromSQL(self.cnx,
                                control_aplicacion.strSelectDetalleControl % (tabla, codigo))
        if self.modelo_control is None:
            self.modelo_control = gtk.ListStore(*(10*[str]))
        self.treeControl.set_model(self.modelo_control)
    
    def on_btnAnadirControl_clicked(self, btn=None):
        
        if self.rut_control is None:
            dialogos.error("Debe indicar un responsable")
            return
        
        if self.codigo_tipo_control is None:
            dialogos.error("Debe indicar un Tipo de control")
            return
        
        it = self.modelo_control.append()
        
        self.modelo_control.set_value(it, CODIGO_CONTROL, self.entCodigoControl.get_text())
        self.modelo_control.set_value(it, CODIGO_TIPO_CONTROL, self.codigo_tipo_control)
        self.modelo_control.set_value(it, DESCRIPCION_TIPO_CONTROL, self.entTipoControl.get_text())
        self.modelo_control.set_value(it, RESULTADO_CONTROL, self.spnValorResultado.get_value())
        self.modelo_control.set_value(it, DESCRIPCION_RESULTADO, self.entResultadoControl.get_text().upper())
        self.modelo_control.set_value(it, UNIDAD_MEDICION, self.descripcion_unidad )
        self.modelo_control.set_value(it, FECHA_CONTROL, self.entFechaControl.get_date())
        self.modelo_control.set_value(it, HORA_CONTROL, self.entHoraControl.get_text())
        self.modelo_control.set_value(it, RUT_CONTROL, self.rut_control)
        self.modelo_control.set_value(it, NOMBRE_CONTROL, self.entResponsableControl.get_text())
        self.rut_control = None
        self.codigo_tipo_control = None
        
        self.clear_form()
        self.hbResultadoN.set_sensitive(False)
        self.hbResultadoT.set_sensitive(False)
        self.entTipoControl.grab_focus()
        
    def on_btnQuitarControl_clicked(self, btn=None):
        model, it = self.treeControl.get_selection().get_selected()
        
        if model is None or it is None:
            return
        model.remove(it)
        
    def on_treeControl_row_activated(self, tree, path, col):
        model, it = self.treeControl.get_selection().get_selected()
        if model is None or it is None:
            return
        
        self.entCodigoControl.set_text(model.get_value(it, CODIGO_CONTROL))
        self.codigo_tipo_control = self.pecTipoControl.select(model.get_value(it, DESCRIPCION_TIPO_CONTROL), 1)
        self.spnValorResultado.set_value(float(model.get_value(it, RESULTADO_CONTROL)))
        self.entResultadoControl.set_text(model.get_value(it, DESCRIPCION_RESULTADO))
        self.descripcion_unidad =  model.get_value(it, UNIDAD_MEDICION)
        if self.entResultadoControl.get_text() == "":
            self.hbResultadoN.set_sensitive(True)
            self.hbResultadoT.set_sensitive(False)
            self.entResultadoN.set_text(self.descripcion_unidad)
        else:
            self.hbResultadoN.set_sensitive(False)
            self.hbResultadoT.set_sensitive(True)
            self.entResultadoT.set_text(self.descripcion_unidad)
        fecha = comunes.GetDateFromModel(model.get_value(it, FECHA_CONTROL).split()[0])
        self.entFechaControl.set_date(fecha)
        self.entHoraControl.set_text(model.get_value(it, HORA_CONTROL))
        self.rut_control = self.pecResponsableControl.select(model.get_value(it, NOMBRE_CONTROL), 1)
        
        model.remove(it)

CODIGO_RELACION = 0
PORCENTAJE = 1

class vboxRelacion(GladeConnect):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion", filtro=""):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        
        self.padre = padre
        self.codigo_relacion = None
        
        if padre is None:
            self.frm_padre = self.wnRelacion
        else:
            self.frm_padre = self.padre.frm_padre
        
        self.pecRelacion = completion.GenericCompletion(self.entCodigoRelacion,
                                self.sel_relacion,
                                self.cnx,
                                filtro)
        
        self.entTotal.set_text("0")
        self.crea_columnas()
        
        self.frm_padre.show_all()
        
    def sel_relacion(self, completion, model, iter):
        self.codigo_relacion = model.get_value(iter, 0)
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_RELACION, "Código", "str"])
        columnas.append ([PORCENTAJE, "Porcentaje", "str"])
        
        self.modelo_relacion = gtk.ListStore(*(len(columnas)*[str]))
        self.columnas = columnas
        SimpleTree.GenColsByModel(self.modelo_relacion, columnas, self.treeRelacion)
        
    
    def calcula_total(self):
        total = 0
        try:
            for i in self.modelo_relacion:
                total += (float(i[2]) * (float(i[1])/100))
        except:
            total = 0
    
        self.entTotal.set_text(str(total))
        
    def guarda_modelo(self, tabla, campo_llave, valor_llave, campo_relacion):
        
        llaves = {campo_llave : valor_llave}
        
        # Elimina todos los registros anteriores
        sql = ifd.deleteFromDict(tabla, llaves)
        self.cursor.execute(sql, llaves)
        
        if self.modelo_relacion is None:
            return
        campos = {}
        campos[campo_llave] = valor_llave
        
        for i in self.modelo_relacion:
            campos[campo_relacion] = i[CODIGO_RELACION]
            campos['porcentaje'] = i[PORCENTAJE]
            sql = ifd.insertFromDict(tabla, campos)
            self.cursor.execute(sql, campos)

    def carga_modelo(self, tabla, campo_llave, valor_llave, campo_relacion):
        llaves = {campo_llave: valor_llave}
        
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx,
                        basicas.strSelectDetalleRelacion % (campo_relacion,
                                                        tabla,
                                                        campo_llave,
                                                        valor_llave))
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(len(self.columnas)*[str]))
            
        self.treeRelacion.set_model(self.modelo_relacion)
    
    def on_btnAnadirRelacion_clicked(self, btn=None):
        
        if self.codigo_relacion is None:
            return
        
        datos = [i[0] for i in self.modelo_relacion if i[0]==self.codigo_relacion]
        
        if len(datos)>0:
            return
        
        it = self.modelo_relacion.append()
        
        self.modelo_relacion.set_value(it, CODIGO_RELACION, self.entCodigoRelacion.get_text())
        
        self.clear_form()
        self.entCodigoRelacion.grab_focus()
        self.codigo_relacion = None
        
    def on_btnQuitarRelacion_clicked(self, btn=None):
        model, it = self.treeRelacion.get_selection().get_selected()
        
        if model is None or it is None:
            return
        model.remove(it)
        self.clear_form()
        self.codigo_relacion = None
        self.entCodigoRelacion.grab_focus()
        self.calcula_total()
        
    def on_treeRelacion_row_activated(self, tree, path, col):
        model, it = self.treeRelacion.get_selection().get_selected()
        if model is None or it is None:
            return
        
        self.entCodigoRelacion.set_text(model.get_value(it, CODIGO_RELACION))
        self.codigo = model.get_value(it, CODIGO_RELACION)
        
        model.remove(it)
        self.calcula_total()


class vboxDetalle(vboxRelacion):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion", filtro_busqueda=""):
        vboxRelacion.__init__(self, conexion, padre, root, filtro_busqueda)
        self.codigo = None
        self.volumen = None
        self.estanque = None
        self.fecha = None
        self.hora = None
        
        self.spnVolumen.set_value(float("0"))

    def crea_columnas(self):
        columnas = []
        columnas.append ([0, "Código", "str"])
        columnas.append ([1, "Porcentaje", "str"])
        columnas.append ([2, "Volumen", "str"])
        columnas.append ([3, "Estanque", "str"])
        columnas.append ([4, "Fecha", "dte"])
        columnas.append ([5, "Hora", "str"])
        self.columnas = columnas
        self.modelo_relacion = gtk.ListStore(*(len(columnas)*[str]))
        SimpleTree.GenColsByModel(self.modelo_relacion, columnas, self.treeRelacion)
    
    def sel_relacion(self, completion, model, iter):
        self.codigo = model.get_value(iter, 0)
        self.volumen = model.get_value(iter, 1)
        self.estanque = model.get_value(iter, 2)
        self.fecha = model.get_value(iter, 3)
        self.hora = model.get_value(iter, 4)
        
    def on_btnAnadirRelacion_clicked(self, btn=None):
        
        if self.codigo is None:
            return
        
        datos = [i[0] for i in self.modelo_relacion if i[0] == self.codigo]
        
        if len(datos) > 0:
            return
        
        if self.spnVolumen.get_value() > 0:            
            porcentaje = float(self.spnVolumen.get_value() * 100 / float(self.volumen)  )
            fila = [self.codigo,  float("%.2f" % porcentaje), self.volumen, self.estanque, self.fecha, self.hora]
        else:
            fila = [self.codigo,  self.spnPorcentaje.get_value(), self.volumen, self.estanque, self.fecha, self.hora]
        
        self.modelo_relacion.append(fila)
        self.clear_form()
        self.entCodigoRelacion.grab_focus()
        self.codigo = None
        self.volumen = None
        self.estanque = None
        self.fecha = None
        self.hora = None
        self.spnVolumen.set_value(0.0)
        self.spnPorcentaje.set_value(1.0)
        self.calcula_total()

class vboxFermentacionMaceracion(vboxDetalle):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion"):
        vboxDetalle.__init__(self, conexion, padre, root, maceracion.strSelectFiltroMaceracion)

       
    def carga_modelo(self, valor_llave):
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx, fermentacion.strSelectMaceracionFermentacion % valor_llave)
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(len(self.columnas)*[str]))
        self.treeRelacion.set_model(self.modelo_relacion)
        self.calcula_total()
    
class vboxDetalleFermentacion(vboxDetalle):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion", codigo=None):
        where = ""
        if not codigo is None:
            where = "WHERE f.codigo_fermentacion <> %s" % codigo
        filtro = fermentacion.strSelectFiltroFermentacion % where
        vboxDetalle.__init__(self, conexion, padre, root, filtro)
        
    def carga_modelo(self, valor_llave):
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx, fermentacion.strSelectDetalleFermentacion % valor_llave)
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(6*[str]))
        self.treeRelacion.set_model(self.modelo_relacion)
        self.calcula_total()

class vboxMezclaFermentacion(vboxDetalle):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion"):
        vboxDetalle.__init__(self, conexion, padre, root, fermentacion.strSelectFiltroFermentacion % "")
        self.spnRendimiento.set_sensitive(True)

    def carga_modelo(self, valor_llave):
        sql = mezcla.strSelectFermentacionMezcla.replace("hora_fermentacion", "hora_fermentacion, fm.rendimiento")
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx, sql % valor_llave)
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(7*[str]))
        self.treeRelacion.set_model(self.modelo_relacion)
        self.calcula_total()
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([0, "Código", "str"])
        columnas.append ([1, "Porcentaje", "str"])
        columnas.append ([2, "Volumen", "str"])
        columnas.append ([3, "Estanque", "str"])
        columnas.append ([4, "Fecha", "dte"])
        columnas.append ([5, "Hora", "str"])
        columnas.append ([6, "Rendimiento", "str"])
        self.columnas = columnas
        self.modelo_relacion = gtk.ListStore(*(len(columnas)*[str]))
        SimpleTree.GenColsByModel(self.modelo_relacion, columnas, self.treeRelacion)
        
    def calcula_total(self):
        total = 0
        try:
            for i in self.modelo_relacion:
                total += (float(i[2]) * (float(i[1])/100)) * (float(i[6])/100)
        except:
            total = 0
    
        self.entTotal.set_text(str(total))
        
    def on_btnAnadirRelacion_clicked(self, btn=None):
        
        if self.codigo is None:
            return
        
        datos = [i[0] for i in self.modelo_relacion if i[0]==self.codigo]
        
        if len(datos)>0:
            return
        
        if self.spnVolumen.get_value() > 0:            
            porcentaje = float(self.spnVolumen.get_value() * 100 / float(self.volumen)  )
            fila = [self.codigo,  float("%.2f" % porcentaje), self.volumen, self.estanque, self.fecha, self.hora, self.spnRendimiento.get_value()]
        else:
            fila = [self.codigo,  self.spnPorcentaje.get_value(), self.volumen, self.estanque, self.fecha, self.hora, self.spnRendimiento.get_value()]
        
        self.modelo_relacion.append(fila)
        self.clear_form()
        self.entCodigoRelacion.grab_focus()
        self.codigo = None
        self.volumen = None
        self.estanque = None
        self.fecha = None
        self.hora = None
        self.spnPorcentaje.set_value(1.0)
        self.spnRendimiento.set_value(1.0)
        self.calcula_total()
        
    def guarda_modelo(self, tabla, campo_llave, valor_llave, campo_relacion):
        
        llaves = {campo_llave: valor_llave}
        
        # Elimina todos los registros anteriores
        sql = ifd.deleteFromDict(tabla, llaves)
        self.cursor.execute(sql, llaves)
        
        if self.modelo_relacion is None:
            return
        campos = {}
        campos[campo_llave] = valor_llave
        
        
        for i in self.modelo_relacion:
            campos[campo_relacion] = i[CODIGO_RELACION]
            campos['porcentaje'] = i[PORCENTAJE]
            campos['rendimiento'] = i[6]
            sql = ifd.insertFromDict(tabla, campos)
            self.cursor.execute(sql, campos)
            
    def on_treeRelacion_row_activated(self, tree, path, col):
        model, it = self.treeRelacion.get_selection().get_selected()
        if model is None or it is None:
            return
        
        self.entCodigoRelacion.set_text(model.get_value(it, CODIGO_RELACION))
        self.spnPorcentaje.set_value(float(model.get_value(it, PORCENTAJE)))
        self.spnRendimiento.set_value(float(model.get_value(it, 6)))
        self.codigo = model.get_value(it, CODIGO_RELACION)
        fila = [self.codigo,  self.spnPorcentaje.get_value(), self.volumen, self.estanque, self.fecha, self.hora, self.spnRendimiento.get_value()]
        self.volumen = model.get_value(it, 2)
        self.estanque = model.get_value(it, 3)
        self.fecha = model.get_value(it, 4)
        self.hora = model.get_value(it, 5)
        model.remove(it)
        self.calcula_total()
    
class vboxDetalleMezcla(vboxDetalle):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion", codigo=None):
        where = ""
        if not codigo is None:
            where = "WHERE m.codigo_mezcla <> %s" % codigo
        filtro=mezcla.strSelectFiltroMezcla % where
        vboxDetalle.__init__(self, conexion, padre, root, filtro)
        
    def carga_modelo(self, valor_llave):
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx, mezcla.strSelectDetalleMezcla % valor_llave)
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(6*[str]))
        self.treeRelacion.set_model(self.modelo_relacion)
        self.calcula_total()

class vboxDetalleEmbotellado(vboxDetalle):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion", codigo=None):
        where = ""
        if not codigo is None:
            where = "WHERE m.codigo_embotellado <> %s" % codigo
        filtro=embotellado.strSelectFiltroEmbotellado % where
        vboxDetalle.__init__(self, conexion, padre, root, filtro)
        
    def carga_modelo(self, valor_llave):
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx, embotellado.strSelectDetalleEmbotellado % valor_llave)
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(6*[str]))
        self.treeRelacion.set_model(self.modelo_relacion)
        self.calcula_total()
        
class vboxEmbotelladoMezcla(vboxDetalle):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion"):
        vboxDetalle.__init__(self, conexion, padre, root, mezcla.strSelectFiltroMezcla % "")

       
    def carga_modelo(self, valor_llave):
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx, embotellado.strSelectMezclaEmbotellado % valor_llave)
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(6*[str]))
        self.treeRelacion.set_model(self.modelo_relacion)
        self.calcula_total()

class vboxMaceracionRecepcion(vboxDetalle):
    
    def __init__(self, conexion=None, padre=None, root="vboxRelacion", codigo=None):
        vboxDetalle.__init__(self, conexion, padre, root, recepcion_uva.strSelectFiltroRecepcionUva)
        self.codigo = None
        self.cantidad = None
        self.cuartel = None
        self.fecha = None
        self.hora = None
    
    def crea_columnas(self):
        columnas = []
        columnas.append ([0, "Código", "str"])
        columnas.append ([1, "Porcentaje", "str"])
        columnas.append ([2, "Cantidad", "str"])
        columnas.append ([3, "Cuartel", "str"])
        columnas.append ([4, "Fecha", "dte"])
        columnas.append ([5, "Hora", "str"])
        
        self.modelo_relacion = gtk.ListStore(*(len(columnas)*[str]))
        self.columnas = columnas
        SimpleTree.GenColsByModel(self.modelo_relacion, columnas, self.treeRelacion)
    
    def sel_relacion(self, completion, model, iter):
        self.codigo = model.get_value(iter, 0)
        self.cantidad = model.get_value(iter, 1)
        self.cuartel = model.get_value(iter, 2)
        self.fecha = model.get_value(iter, 3)
        self.hora = model.get_value(iter, 4)
    
    def on_btnAnadirRelacion_clicked(self, btn=None):
        
        if self.codigo is None:
            return
        
        datos = [i[0] for i in self.modelo_relacion if i[0]==self.codigo]
        
        if len(datos)>0:
            return
        
        if self.spnVolumen.get_value() > 0:            
            porcentaje = float(self.spnVolumen.get_value() * 100 / float(self.cantidad)  )
            fila = [self.codigo, float("%.2f" % porcentaje), self.cantidad, self.cuartel, self.fecha, self.hora]
        else:
            fila = [self.codigo, self.spnPorcentaje.get_value(), self.cantidad, self.cuartel, self.fecha, self.hora]
            
        
        
        if len(self.modelo_relacion) == 0:
            self.modelo_relacion = gtk.ListStore(*(len(self.columnas)*[str]))
            self.treeRelacion.set_model(self.modelo_relacion)
        
        self.modelo_relacion.append(fila)
        self.clear_form()
        self.entCodigoRelacion.grab_focus()
        self.codigo = None
        self.cantidad = None
        self.cuartel = None
        self.fecha = None
        self.hora = None
        self.spnPorcentaje.set_value(1.0)
        self.calcula_total()
    
    def carga_modelo(self, valor_llave):
        self.modelo_relacion = ifd.ListStoreFromSQL(self.cnx, maceracion.strSelectMaceracionRecepcionUva % valor_llave)
        if self.modelo_relacion is None:
            self.modelo_relacion = gtk.ListStore(*(5*[str]))
        self.treeRelacion.set_model(self.modelo_relacion)
        self.calcula_total()

def revisa_movimiento_estanque(cnx):
    cu = cnx.cursor()
    cu.execute("select * from traza.vw_movimiento_estanque")
    r = cu.dictfetchall()
    cu.execute("begin")
    try:
        for i in r:
            if i["volumen"] <= 100:
                print i["volumen"], i["code_a"], i["porcentaje"]
                cu.execute("select capacidad_estanque from traza.estanque where codigo_estanque = %s" % i["code_a"])
                r1 = cu.dictfetchall()
                print "----", r1[0]["capacidad_estanque"]
                campo = "volumen"
                if i["tipo"] == 1:
                    tabla = "volumen_maceracion"
                if i["tipo"] == 2:
                    tabla = "fermentacion"
                if i["tipo"] == 3:
                    tabla = "fermentacion"
                if i["tipo"] == 4:
                    tabla = "mezcla"
                if i["tipo"] == 5:
                    tabla = "mezcla"
                sql = """update traza.%s set %s = %s
                            where codigo_%s = %s""" % (tabla,
                                                       campo,
                                                       (i["porcentaje"]/100) * r1[0]["capacidad_estanque"],
                                                       tabla,
                                                       i['cod_a'])
                print sql
                #cu.execute("update traza.%s set %s = %s" % (tabla, campo, (i["porcentaje"]/100) * r1[0]["capacidad_estanque"]))
        cu.execute("commit")
    except:
        print "rollback"
        print sys.exc_info()[1]
        cu.execute("rollback")

(CODIGO_A_DESPACHAR,
 DETALLE,
 CANTIDAD,
 CODIGO_DESPACHO) = range (4)
class Despachos (GladeConnect):
    def __init__ (self, conexion=None, padre=None, root="vboxTipoDespacho",tipo = "", carga ="", despachos=None ):
        GladeConnect.__init__(self, "glade/wnDespacho.glade", root)        
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.codigo_despachos = None
        self.detalle_despacho = None
        self.despachos = despachos
        
        self.pecDespacho = completion.GenericCompletion(self.entCodigo,
                                self.sel_despachos,
                                self.cnx,
                                tipo)
        self.crea_columnas()
        self.carga_datos(carga)
        self.calcula_total()
        
    def calcula_total(self):
        total = 0
        try:
            for i in self.modelo_despacho:
                total += float(i[2])
        except:
            total = 0
        self.entTotal.set_text(str(total))
        
    def sel_despachos(self, completion, model, iter):
        self.codigo_despachos = model.get_value(iter, 0)    
        self.detalle_despacho = model.get_value(iter, 2)
     
        if self.despachos:
            sql="""select sum (e.cantidad)- sum(ed.cantidad)
                from traza.embotellado e
                join traza.embotellado_despacho ed
                using (codigo_embotellado) where e.codigo_embotellado = %s""" %(self.codigo_despachos)
            self.cursor.execute(sql)
            reg = self.cursor.fetchone()
        
            if reg[0] is None:
                    sql = """select sum(e.cantidad) from traza.embotellado e
                            where e.codigo_embotellado = %s""" %(self.codigo_despachos)
                    self.cursor.execute(sql)
                    reg = self.cursor.fetchone()
        
        else:
            sql = """select sum(m.volumen) - sum(md.cantidad) from traza.mezcla m
                            join  traza.mezcla_despacho md
                            using(codigo_mezcla) where m.codigo_mezcla = %s""" %(self.codigo_despachos)
            self.cursor.execute(sql)
            reg = self.cursor.fetchone()
            if reg[0]  is None:
                    sql = """select sum(m.volumen) from traza.mezcla m
                            where m.codigo_mezcla = %s""" %(self.codigo_despachos)
                    self.cursor.execute(sql)
                    reg = self.cursor.fetchone()
                    
        self.spnDisponible.set_value(float(reg[0]))
        if self.spnDisponible.get_value() <= 0:
            dialogos.info("<b>No hay disponibilidad para ese producto</b>")
            self.codigo_despachos = None
            return

    def crea_columnas(self):
        columnas = []
        #columnas.append ([CODIGO_DESPACHO, "Código", "int"])
        columnas.append ([CODIGO_A_DESPACHAR, "Código", "int"])
        columnas.append ([DETALLE, "Detalle", "str"])
        columnas.append ([CANTIDAD, "Cantidad", "str"])
        
        self.modelo_despacho = gtk.ListStore(*(3*[str]))
        self.columnas = columnas
        SimpleTree.GenColsByModel(self.modelo_despacho, columnas, self.treeTipoDespacho)
    
    def carga_datos(self, carga):
        try:
            self.modelo_despacho = ifd.ListStoreFromSQL(self.cnx, carga)
        except:()
        if self.modelo_despacho is None:
            self.modelo_despacho = gtk.ListStore(*(3*[str]))
        self.treeTipoDespacho.set_model(self.modelo_despacho)
        
    def on_btnAnadir_clicked(self, btn=None):
        if self.codigo_despachos is None:
            return
        
        if self.spnCantidad.get_value() > self.spnDisponible.get_value():
            dialogos.error("<b>La cantidad que desea despachar es mayor a la cantidad disponible en Stock</b>")
            return
        
        if self.spnCantidad.get_value() <= 0 and self.spnPorcentaje <= 0:
            dialogos.error("<b>La cantidad a despachar debe ser mayor a cero</b>")
            return
        
        datos = [i[0]for i in self.modelo_despacho if i[0]==self.codigo_despachos]
        
        if len(datos)>0:
            return
        
        if self.spnCantidad.get_value() > 0:
            cantidad = self.spnCantidad.get_value()
        else:
            cantidad = round((float(self.spnPorcentaje.get_value())*float(self.spnDisponible.get_value()))/100, 2)
        
        fila = [self.codigo_despachos,  self.detalle_despacho, cantidad]
        
        self.modelo_despacho.append(fila)
        self.calcula_total()
        self.clear_form()
        self.entCodigo.grab_focus()
        self.codigo_despachos = None

    def on_btnQuitar_clicked(self, btn=None):
        model, it = self.treeTipoDespacho.get_selection().get_selected()
        if model is None or it is None:
            return
        model.remove(it)
        self.calcula_total()
        self.clear_form()
        self.codigo_despachos = None
        self.entCodigo.grab_focus()
        
        
    def guarda_despacho(self, tabla, campo_llave, valor_llave, campo_despacho):
        
        llaves = {campo_llave: valor_llave}
        # Elimina todos los registros anteriores
        sql = ifd.deleteFromDict(tabla, llaves)
        self.cursor.execute(sql, llaves)
        
        if self.modelo_despacho is None:
            return
        campos = {}
        campos[campo_llave] = valor_llave
        
        for i in self.modelo_despacho:
            campos['codigo_despacho'] = valor_llave
            campos['cantidad'] = i[CANTIDAD]
            campos[campo_despacho] = i[CODIGO_A_DESPACHAR]
            sql = ifd.insertFromDict(tabla, campos)
            self.cursor.execute(sql, campos)
    

class vboxDespachoEmbotellado(Despachos):
    
    def __init__(self, conexion=None, padre=None, codigo_despacho=None, root="vboxTipoDespacho", ):
        Despachos.__init__(self, conexion, padre, root, embotellado.strSelectFiltroEmbotellado % "", embotellado.strSelectDespachoEmbotellado %codigo_despacho, despachos=True)


class vboxDespachoMezcla(Despachos):
    
    def __init__(self, conexion=None, padre=None, codigo_despacho=None, root="vboxTipoDespacho"):
        Despachos.__init__(self, conexion, padre, root, mezcla.strSelectFiltroMezcla % "", mezcla.strSelectDespachoMezcla %codigo_despacho, despachos = False)


if __name__ == '__main__':
    cnx = connect("dbname=traza")
    cnx.autocommit()
    #revisa_movimiento_estanque(cnx)
    #sys.excepthook = debugwindow.show
    #d = vboxAplicacion(cnx, root="wnAplicacion")
    #d = vboxControl(cnx, root="wnControl")
    
    #gtk.main()        
